package Controlador;

import java.util.Vector;
import Clases.*;
import Vista.*;
import Persistencia.*;


public class controlador {
	
	private Vector<Cliente> clientes;
	private Vector<Seccion> secciones;
	private Vector<Pedido> pedidos;
	private Vector<Descuento> descuentos;
	private Vector<Comida> comidas;
	private Vector<Producto> productos;
	private Vector<Receta> recetas;
	
	private static controlador instancia;
	
	
	private controlador(){
		clientes = new Vector<Cliente>();
		secciones = new Vector<Seccion>();
		pedidos = new Vector<Pedido>();
		descuentos = new Vector<Descuento>();
		comidas = new Vector<Comida>();
		productos = new Vector<Producto>();
		recetas = new Vector<Receta>();
	}
	
	public static controlador getInstancia(){
		if(instancia == null)
			return instancia = new controlador();
		return instancia;
	}
	
//----------------------------------- METODOS DE BUSQUEDA -----------------------------------//
	
	public Descuento buscarDescuento(int idDescuento){
		for(int i=0; i<descuentos.size(); i++){
			if(descuentos.elementAt(i).sosDescuento(idDescuento)){     
				return descuentos.elementAt(i);
			}
		}		
		//HAY QUE BUSCAR EN LA BASE DE DATOS
		return null;
	}
		
	public Producto buscarProducto(int codBarra){
		for(int i=0; i<productos.size(); i++){
			if(productos.elementAt(i).sosProducto(codBarra)){        
				return productos.elementAt(i);
			}
		}
		Producto p = DAOProducto.getInstancia().buscarProducto(codBarra);
		if(p!= null){
			productos.add(p);
			return p;
		}
		return null;
	}
	
	public Comida buscarComida(String nombreCom){
		for(int i=0; i<comidas.size(); i++){
			if(comidas.elementAt(i).sosComida(nombreCom)){         
				return comidas.elementAt(i);
			}
		}		
		Comida C = DAOComida.getInstancia().buscarComida(nombreCom);
		if(C != null && C.getActivo() == 1){
			comidas.add(C);
			return C;
		}
		return null;
	}
	
	public Cliente buscarCliente(int telefono){
		for(int i=0; i<clientes.size(); i++){
			if(clientes.elementAt(i).sosCliente(telefono)){
				return clientes.elementAt(i);
			}
		}		
		//HAY QUE BUSCAR EN LA BASE DE DATOS
		return null;
	}
	
	public Seccion buscarSeccion(String nombreSec){
		for(int i=0; i<secciones.size(); i++){
			if(secciones.elementAt(i).sosSeccion(nombreSec)){
				return secciones.elementAt(i);
			}
		}		
		Seccion S = DAOSeccion.getInstancia().buscarSeccion(nombreSec);
		if(S != null){
			secciones.add(S);
			return S;
		}	
		return null;
	}
	
	public Pedido buscarPedido(int numPedido){
		for(int i=0; i<pedidos.size(); i++){
			if(pedidos.elementAt(i).sosPedido(numPedido)){
				return pedidos.elementAt(i);
			}
		}
		//HAY QUE BUSCAR EN LA BASE DE DATOS
		return null;
	}
	
	public Receta buscarReceta(String nomReceta){
		for(int i=0; i<recetas.size(); i++){
			if(recetas.elementAt(i).getNombre().equalsIgnoreCase(nomReceta)){
				return recetas.elementAt(i);
			}
		}
		Receta R = DAOReceta.getInstancia().buscarReceta(nomReceta);
		if(R != null){
			recetas.add(R);
			return R;
		}
		return null;
	}

	
//----------------------------------- ABM DE PRODUCTOS -----------------------------------//
	
	public boolean altaProducto(String nomProd, String Proveedor, float stock, String unidad, int codBarra, float precio){
		Producto prod = buscarProducto(codBarra); 
		if(prod == null){
			Producto P = new Producto(nomProd, Proveedor, stock, unidad, codBarra,precio);
			productos.add(P);
			DAOProducto.getInstancia().insert(P);
			return true;
		}else{
			if(prod.getActivo() == 0){                  //Significa que esta inactivo pero existe en el sistema entonces 
				prod.setActivo(1);						//lo activo y le pongo los atributos que ingreso el usuario.
				prod.setProveedor(Proveedor);
				prod.setStockTotal(stock);
				prod.setUnidad(unidad);
				prod.setNombre(nomProd);
				DAOProducto.getInstancia().update(prod);
				return true;
			}
			return false;
		}
	}
	
	public boolean modProducto(int codBarra, String nomProd, String Proveedor, float stock, String unidad, float precio){
		Producto prod = buscarProducto(codBarra);
		if(prod == null)
			return false;
		else{
			//NO NECESITO PREGUNTAR SI EL PRODUCTO ESTA ACTIVO PORQUE LO PREGUNTO EN EL DAO,
			//SOLO LLENO LA LISTA CON LOS PRODUCTOS ACTIVOS.
			prod.setNombre(nomProd);
			prod.setProveedor(Proveedor);
			prod.setStockTotal(stock);
			prod.setUnidad(unidad);
			prod.setPrecio(precio);
			DAOProducto.getInstancia().update(prod);
			return true;
		}
	}
	
	public boolean bajaProducto(int codBarra){
		Producto prod = buscarProducto(codBarra);
		if(prod == null){
			return false;
		} else {
			prod.setActivo(0);
			return DAOProducto.getInstancia().delete(prod);
		}
		
	}

	//----------------------------------- ABM DE SECCIONES -----------------------------------//

    
    public boolean altaSeccion(String nomSec, String especialidad, Vector<ProductoSeccion> prodSec){
    if (prodSec==null){
    	prodSec=new Vector<ProductoSeccion>();
    }
    Seccion seccion = buscarSeccion(nomSec);
     if(seccion  == null){
      Seccion S = new Seccion(nomSec, especialidad, prodSec);
      secciones.add(S);
      DAOSeccion.getInstancia().insert(S);
      return true;
     }else{
      if(seccion.getActivo() == 0){                  //Significa que esta inactivo pero existe en el sistema entonces
       seccion.setActivo(1);      //lo activo y le pongo los atributos que ingreso el usuario.
       seccion.setEspecialidad(especialidad);
       DAOSeccion.getInstancia().update(seccion);
       return true;
      }
      return false;
     }
    }
    
    public boolean modSeccion(String nomSec, String especialidad, int id){
     Seccion sec = buscarSeccion(nomSec);
     if(sec == null)
      return false;
     else{
      sec.setNombre(nomSec);
      sec.setEspecialidad(especialidad);
      DAOSeccion.getInstancia().update(sec);
      return true;
     }
    }
    
    public boolean bajaSeccion(String nomSec){
    	Seccion sec = buscarSeccion(nomSec);
    	if(sec == null){
    		return false;
    	} else {
    		sec.setActivo(0);
    		DAOSeccion.getInstancia().delete(sec);
    		return true;
    	}
    }
    
    
    public ProductoSeccion buscarProductoSeccion(int idP, String nomSec){
            
            for(int i=0; i<secciones.size(); i++){
                           if(secciones.elementAt(i).sosSeccion(nomSec)) {      
                                   Seccion s = secciones.elementAt(i);
                                   if (s.getProductosEnStock()!=null){
	                                   for (int j=0; j < s.getProductosEnStock().size(); j++){
	                                           if (s.getProductosEnStock().elementAt(j).getProducto().sosProducto(idP))
	                                                   return s.getProductosEnStock().elementAt(j);
	                                   }
                                   }
                           }
                   }
                   ProductoSeccion prodSec = DAOProductoSeccion.getInstancia().buscarSeccionProducto(idP, nomSec);
                   if(prodSec!= null){
                           return prodSec;
                   }
                   return null;
    }
    
    
    
    
   //----------------------------------- ABM DE PRODUCTOSECCION -----------------------------------//

    public boolean altaProductoSeccion(int idProducto, float f, String nomSec){
     ProductoSeccion prodSec = buscarProductoSeccion(idProducto, nomSec);
     if(prodSec  == null){
      Producto pr = buscarProducto(idProducto);
      Seccion s = buscarSeccion(nomSec);
      ProductoSeccion pSec = new ProductoSeccion(nomSec, pr, f);
      s.getProductosEnStock().add(pSec);
      DAOProductoSeccion.getInstancia().insert(pSec);
      return true;
     }
      return false;
     }
    
    
    public boolean modSeccionProducto(String nomSec, int idP, float f){
     ProductoSeccion pSec = buscarProductoSeccion(idP, nomSec);
     if(pSec == null)
             return false;
     else{
    	 		pSec.setStock(f);
//             if(f>0){
//                     pSec.incrementarStock(f);
//                     DAOProductoSeccion.getInstancia().update(pSec);
//             }else{
//                     pSec.decrementarStock(f);
//                     DAOProductoSeccion.getInstancia().update(pSec);
//             }
             return true;
     }
    }


//----------------------------------- ABM DE COMIDA -----------------------------------//	
	
	@SuppressWarnings("static-access")
	public boolean altaComida(String nombre, String tipoComida, String nomReceta, String nomSeccion){
		Comida comida = controlador.getInstancia().buscarComida(nombre);
		if(comida == null){
			Comida C = new Comida(nombre, tipoComida, nomSeccion);
			comidas.add(C);
			Receta R = buscarReceta(nomReceta);
			C.setReceta(R);
			Seccion S = buscarSeccion(nomSeccion);
			C.setSeccion(S);
			DAOComida.getInstancia().insert(C);
			return true;
		} else {
			if(comida.getActivo() == 0){
				comida.setActivo(1);
				Receta R = buscarReceta(nomReceta);
				comida.setReceta(R);
				Seccion S = buscarSeccion(nomSeccion);
				comida.setSeccion(S);
				DAOComida.getInstancia().insert(comida);
				return true;
			}
		}
		return false;
	}

	public boolean modComida(String nombre, String tipoComida){
		Comida comida = buscarComida(nombre);
		if(comida == null)
			return false;
		else{
			comida.setTipoComida(tipoComida);
			DAOComida.getInstancia().update(comida);
			return true;
		}
	}
	
	public boolean bajaComida(String nombre){
		Comida comida = buscarComida(nombre);
		if(comida == null){
			return false;
		} else {
			comida.setActivo(0);
			DAOComida.getInstancia().delete(comida);
			return true;
		}
	}
	
		
//----------------------------------- METODOS DE NEGOCIO -----------------------------------//

//----------------------------------- METODOS DE VISTAS -----------------------------------//
	
	public Vector<ProductoView> getProductoView()
	{
		Vector<ProductoView> vec = new Vector<ProductoView>();
		productos = DAOProducto.getInstancia().buscarTodosProductos();
		for(int i=0;i<productos.size();i++){
			if(productos.elementAt(i).getView() != null)
				vec.add(productos.elementAt(i).getView());
		}
		return vec;
	}
	
	public ProductoView getProductoView(int codBarra)
	{
		ProductoView viewResultado = null;
		Producto elemento = controlador.getInstancia().buscarProducto(codBarra);
		viewResultado = elemento.getView();
		return viewResultado;
	}
	
	public Vector<ComidaView> getComidaView()
	{
		Vector<ComidaView> vec = new Vector<ComidaView>();
		comidas = DAOComida.getInstancia().buscarTodasComidas();
		for(int i=0;i<comidas.size();i++){
			if(comidas.elementAt(i).getView() != null)
				vec.add(comidas.elementAt(i).getView());
		}
		return vec;
	}
	
	public ComidaView getComidaView(String nombreComida)
	{
		ComidaView viewResultado = null;
		Comida elemento = controlador.getInstancia().buscarComida(nombreComida);
		viewResultado = elemento.getView();
		return viewResultado;
	}
	
	public Vector<RecetaView> getRecetaView()
	{
		Vector<RecetaView> vec = new Vector<RecetaView>();
		recetas = DAOReceta.getInstancia().buscarTodasRecetas();
		for(int i=0;i<recetas.size();i++){
			if(recetas.elementAt(i).getView() != null)
				vec.add(recetas.elementAt(i).getView());
		}
		return vec;
	}
	
	public RecetaView getRecetaView(String nombreReceta)
	{
		RecetaView viewResultado = null;
		Receta elemento = controlador.getInstancia().buscarReceta(nombreReceta);
		viewResultado = elemento.getView();
		return viewResultado;
	}
	
	public Vector<SeccionView> getSeccionView(){
		Vector<SeccionView> vec = new Vector<SeccionView>();
		secciones = DAOSeccion.getInstancia().buscarTodasSecciones();
		for(int i=0;i<secciones.size();i++){
			if(secciones.elementAt(i).getView() != null)
				vec.add(secciones.elementAt(i).getView());
		}
		return vec;
	}
	
	public SeccionView getSeccionView(String nombreSeccion)
	{
		SeccionView viewResultado = null;
		Seccion elemento = controlador.getInstancia().buscarSeccion(nombreSeccion);
		viewResultado = elemento.getView();
		return viewResultado;
	}
}